//! # 认证授权服务
//!
//! 基于 rustcloud-security 基础模块，提供企业级认证授权服务的具体实现。

use std::sync::Arc;
use async_trait::async_trait;
use rustcloud_security::prelude::*;

pub mod auth_service;
pub mod builder;

// 重新导出主要类型
pub use auth_service::AuthService;
pub use builder::AuthServiceBuilder;

/// 认证服务配置
#[derive(Debug, Clone)]
pub struct AuthServiceConfig {
    /// 启用的认证提供者
    pub providers: Vec<AuthProviderInfo>,
    /// 默认认证提供者
    pub default_provider: String,
    /// 权限检查配置
    pub permission_enabled: bool,
    /// 会话配置
    pub session_config: SessionConfig,
    /// 安全配置
    pub security_config: SecurityConfig,
}

/// 认证提供者信息
#[derive(Debug, Clone)]
pub struct AuthProviderInfo {
    /// 提供者名称
    pub name: String,
    /// 提供者类型
    pub provider_type: AuthProviderType,
    /// 优先级
    pub priority: i32,
    /// 是否启用
    pub enabled: bool,
}

/// 会话配置
#[derive(Debug, Clone)]
pub struct SessionConfig {
    /// 会话超时时间（秒）
    pub timeout_seconds: u64,
    /// 是否启用会话
    pub enabled: bool,
    /// 最大并发会话数
    pub max_concurrent_sessions: u32,
}

/// 安全配置
#[derive(Debug, Clone)]
pub struct SecurityConfig {
    /// 是否启用审计
    pub audit_enabled: bool,
    /// 密码策略
    pub password_policy: PasswordPolicy,
    /// 令牌配置
    pub token_config: TokenConfig,
}

/// 密码策略
#[derive(Debug, Clone)]
pub struct PasswordPolicy {
    /// 最小长度
    pub min_length: u32,
    /// 是否需要特殊字符
    pub require_special_chars: bool,
    /// 是否需要数字
    pub require_numbers: bool,
    /// 是否需要大写字母
    pub require_uppercase: bool,
}

/// 令牌配置
#[derive(Debug, Clone)]
pub struct TokenConfig {
    /// 访问令牌有效期（秒）
    pub access_token_ttl: u64,
    /// 刷新令牌有效期（秒）
    pub refresh_token_ttl: u64,
    /// 签名算法
    pub signing_algorithm: String,
    /// 签名密钥
    pub signing_key: String,
}

impl Default for AuthServiceConfig {
    fn default() -> Self {
        Self {
            providers: vec![
                AuthProviderInfo {
                    name: "jwt".to_string(),
                    provider_type: AuthProviderType::Jwt,
                    priority: 10,
                    enabled: true,
                },
                AuthProviderInfo {
                    name: "api_key".to_string(),
                    provider_type: AuthProviderType::ApiKey,
                    priority: 5,
                    enabled: true,
                },
            ],
            default_provider: "jwt".to_string(),
            permission_enabled: true,
            session_config: SessionConfig::default(),
            security_config: SecurityConfig::default(),
        }
    }
}

impl Default for SessionConfig {
    fn default() -> Self {
        Self {
            timeout_seconds: 3600, // 1小时
            enabled: true,
            max_concurrent_sessions: 10,
        }
    }
}

impl Default for SecurityConfig {
    fn default() -> Self {
        Self {
            audit_enabled: true,
            password_policy: PasswordPolicy::default(),
            token_config: TokenConfig::default(),
        }
    }
}

impl Default for PasswordPolicy {
    fn default() -> Self {
        Self {
            min_length: 8,
            require_special_chars: true,
            require_numbers: true,
            require_uppercase: true,
        }
    }
}

impl Default for TokenConfig {
    fn default() -> Self {
        Self {
            access_token_ttl: 3600,     // 1小时
            refresh_token_ttl: 86400,   // 24小时
            signing_algorithm: "HS256".to_string(),
            signing_key: "default_key".to_string(), // 在生产环境中应该从环境变量读取
        }
    }
}